<!doctype html>
<html lang="zh-CN">
<head>
  <base href="https://www.nodeapp.cn/cluster.html" />
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title>集群（Cluster） | Node.js 中文文档 | Node.js 中文网</title>
  <meta name="description" content="Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。Node.js 使用了一个事件驱动、非阻塞式 I/O 的模型，使其轻量又高效。Node.js 的包管理器 npm，是全球最大的开源库生态系统。">
  <link rel="stylesheet" href="assets/style.css">
  <link rel="stylesheet" href="assets/sh.css">
  <link rel="canonical" href="https://www.nodeapp.cn/cluster.html">
  <link rel="apple-touch-icon" href="apple-touch-icon.png">
  <link rel="icon" sizes="32x32" type="image/png" href="favicon.png">
  
  <script>
var _hmt = _hmt || [];
(function() {
  var hm = document.createElement("script");
  hm.src = "https://hm.baidu.com/hm.js?acdf78480f7f8f2b23b812565a5868e0";
  var s = document.getElementsByTagName("script")[0]; 
  s.parentNode.insertBefore(hm, s);
})();
</script>

</head>
<body class="alt apidoc" id="api-section-cluster">
  <div id="content" class="clearfix">
    <div id="column1" data-id="cluster" class="interior">
      <header>
        <h1>Node.js v8.x 中文文档</h1>
        <hr>
      </header>

      <div id="toc">
        <h2>目录</h2>
        <ul>
<li><span class="stability_2"><a href="#cluster_cluster">cluster (集群)</a></span><ul>
<li><span class="stability_undefined"><a href="#cluster_how_it_works">How It Works</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_class_worker">Class: Worker</a></span><ul>
<li><span class="stability_undefined"><a href="#cluster_event_disconnect">Event: &apos;disconnect&apos;</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_event_error">Event: &apos;error&apos;</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_event_exit">Event: &apos;exit&apos;</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_event_listening">Event: &apos;listening&apos;</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_event_message">Event: &apos;message&apos;</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_event_online">Event: &apos;online&apos;</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_worker_disconnect">worker.disconnect()</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_worker_exitedafterdisconnect">worker.exitedAfterDisconnect</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_worker_id">worker.id</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_worker_isconnected">worker.isConnected()</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_worker_isdead">worker.isDead()</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_worker_kill_signal_sigterm">worker.kill([signal=&apos;SIGTERM&apos;])</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_worker_process">worker.process</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_worker_send_message_sendhandle_callback">worker.send(message[, sendHandle][, callback])</a></span></li>
<li><span class="stability_0"><a href="#cluster_worker_suicide">worker.suicide</a></span></li>
</ul>
</li>
<li><span class="stability_undefined"><a href="#cluster_event_disconnect_1">Event: &apos;disconnect&apos;</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_event_exit_1">Event: &apos;exit&apos;</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_event_fork">Event: &apos;fork&apos;</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_event_listening_1">Event: &apos;listening&apos;</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_event_message_1">Event: &apos;message&apos;</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_event_online_1">Event: &apos;online&apos;</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_event_setup">Event: &apos;setup&apos;</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_cluster_disconnect_callback">cluster.disconnect([callback])</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_cluster_fork_env">cluster.fork([env])</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_cluster_ismaster">cluster.isMaster</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_cluster_isworker">cluster.isWorker</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_cluster_schedulingpolicy">cluster.schedulingPolicy</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_cluster_settings">cluster.settings</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_cluster_setupmaster_settings">cluster.setupMaster([settings])</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_cluster_worker">cluster.worker</a></span></li>
<li><span class="stability_undefined"><a href="#cluster_cluster_workers">cluster.workers</a></span></li>
</ul>
</li>
</ul>

      </div>
<div id="apicontent">
        <h1>cluster (集群)<span><a class="mark" href="#cluster_cluster" id="cluster_cluster">#</a></span></h1>
<!--introduced_in=v0.10.0-->
<div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">稳定性: 2</a> - 稳定的</div><p>Node.js在单个线程中运行单个实例。
用户(开发者)为了使用现在的多核系统，有时候,用户(开发者)会用一串Node.js进程去处理负载任务。</p>
<p><code>cluster</code> 模块允许简单容易的创建共享服务器端口的子进程。</p>
<pre><code class="lang-js">const cluster = require(&apos;cluster&apos;);
const http = require(&apos;http&apos;);
const numCPUs = require(&apos;os&apos;).cpus().length;

if (cluster.isMaster) {
  console.log(`主进程 ${process.pid} 正在运行`);

  // 衍生工作进程。
  for (let i = 0; i &lt; numCPUs; i++) {
    cluster.fork();
  }

  cluster.on(&apos;exit&apos;, (worker, code, signal) =&gt; {
    console.log(`工作进程 ${worker.process.pid} 已退出`);
  });
} else {
  // 工作进程可以共享任何 TCP 连接。
  // 在本例子中，共享的是一个 HTTP 服务器。
  http.createServer((req, res) =&gt; {
    res.writeHead(200);
    res.end(&apos;你好世界\n&apos;);
  }).listen(8000);

  console.log(`工作进程 ${process.pid} 已启动`);
}
</code></pre>
<p>现在运行 <code>Node.js</code> 将会在工作进程(指代子进程)之间共享8000端口</p>
<pre><code class="lang-txt">$ node server.js
主进程 3596 正在运行
工作进程 4324 已启动
工作进程 4520 已启动
工作进程 6056 已启动
工作进程 5644 已启动
</code></pre>
<p>请注意,在Windows中,还不能在工作进程中设置管道(Pipe)服务器。</p>
<h2>How It Works<span><a class="mark" href="#cluster_how_it_works" id="cluster_how_it_works">#</a></span></h2>
<!--type=misc-->
<p>工作进程由<a href="child_process.html#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>方法创建，因此它们可以使用IPC和父进程通信，从而使各进程交替处理连接服务。</p>
<p>cluster模块支持两种连接分发模式（将新连接安排给某一工作进程处理）。</p>
<p>第一种方法（也是除Windows外所有平台的默认方法），是循环法。由主进程负责监听端口，接收新连接后再将连接循环分发给工作进程。在分发中使用了一些内置技巧防止工作进程任务过载。</p>
<p>第二种方法是，主进程创建监听socket后发送给感兴趣的工作进程，由工作进程负责直接接收连接。</p>
<p>理论上第二种方法应该是效率最佳的，但在实际情况下，由于操作系统调度机制的难以捉摸，会使分发变得不稳定。我们遇到过这种情况：8个进程中的2个，分担了70%的负载。</p>
<p>因为<code>server.listen()</code>将大部分工作交给主进程完成，因此导致普通Node.js进程与cluster作业进程差异的情况有三种：</p>
<ol>
<li><code>server.listen({fd: 7})</code>由于文件描述符“7”是传递给父进程的，这个文件被监听后，将文件句柄（handle）传递给工作进程，而不是文件描述符“7”本身。</li>
<li><code>server.listen(handle)</code> 明确监听句柄，会导致工作进程直接使用该句柄，而不是和父进程通信。</li>
<li><code>server.listen(0)</code> 正常情况下，这种调用会导致server在随机端口上监听。但在cluster模式中，所有工作进程每次调用<code>listen(0)</code>时会收到相同的“随机”端口。实质上，这种端口只在第一次分配时随机，之后就变得可预料。如果要使用独立端口的话，应该根据工作进程的ID来生成端口号。</li>
</ol>
<p><em>注意</em>：Node.js不支持路由逻辑。因此在设计应用时，不应该过分依赖内存数据对象（如sessions和login等）。</p>
<p>由于各工作进程是独立的进程，它们可以根据需要随时关闭或重新生成，而不影响其他进程的正常运行。只要有存活的工作进程，服务器就可以继续处理连接。如果没有存活的工作进程，现有连接会丢失，新的连接也会被拒绝。Node.js不会自动管理工作进程的数量，而应该由具体的应用根据实际需要来管理进程池。</p>
<p>Although a primary use case for the <code>cluster</code> module is networking, it can
also be used for other use cases requiring worker processes.</p>
<h2>Class: Worker<span><a class="mark" href="#cluster_class_worker" id="cluster_class_worker">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.7.0</span>
</div><p>Worker对象包含了关于工作进程的所有public信息和方法。</p>
<p>在一个主进程里，可以使用<code>cluster.workers</code>来获取Worker对象。</p>
<p>在一个工作进程里，可以使用<code>cluster.worker</code>来获取Worker对象。</p>
<h3>Event: &apos;disconnect&apos;<span><a class="mark" href="#cluster_event_disconnect" id="cluster_event_disconnect">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.7.7</span>
</div><p>虽然与 <code>cluster.on(&apos;disconnect&apos;)</code>事件 是相似的,但是这个进程又有其他特征。 </p>
<pre><code class="lang-js">cluster.fork().on(&apos;disconnect&apos;, () =&gt; {
  // Worker has disconnected
});
</code></pre>
<h3>Event: &apos;error&apos;<span><a class="mark" href="#cluster_event_error" id="cluster_event_error">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.7.3</span>
</div><p>此事件和 <a href="child_process.html#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>提供的error事件相同。</p>
<p>在一个工作进程中，可以使用<code>process.on(&apos;error&apos;)</code></p>
<h3>Event: &apos;exit&apos;<span><a class="mark" href="#cluster_event_exit" id="cluster_event_exit">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.11.2</span>
</div><ul>
<li><code>code</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 若正常退出，表示退出代码.</li>
<li><code>signal</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 引发进程被kill的信号名称（如<code>&apos;SIGHUP&apos;</code>）.</li>
</ul>
<p>和<code>cluster.on(&apos;exit&apos;)</code>事件类似，但针对特定的工作进程。</p>
<pre><code class="lang-js">const worker = cluster.fork();
worker.on(&apos;exit&apos;, (code, signal) =&gt; {
  if (signal) {
    console.log(`worker was killed by signal: ${signal}`);
  } else if (code !== 0) {
    console.log(`worker exited with error code: ${code}`);
  } else {
    console.log(&apos;worker success!&apos;);
  }
});
</code></pre>
<h3>Event: &apos;listening&apos;<span><a class="mark" href="#cluster_event_listening" id="cluster_event_listening">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.7.0</span>
</div><ul>
<li><code>address</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a></li>
</ul>
<p>和<code>cluster.on(&apos;listening&apos;)</code>事件类似，但针对特定的工作进程。</p>
<pre><code class="lang-js">cluster.fork().on(&apos;listening&apos;, (address) =&gt; {
  // Worker is listening
});
</code></pre>
<p>本事件不会在工作进程内触发。</p>
<h3>Event: &apos;message&apos;<span><a class="mark" href="#cluster_event_message" id="cluster_event_message">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.7.0</span>
</div><ul>
<li><code>message</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a></li>
<li><code>handle</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&lt;undefined&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a></li>
</ul>
<p>和<code>cluster.on(&apos;message&apos;)</code>事件类似，但针对特定的工作进程。</p>
<p>在工作进程内，可以使用<code>process.on(&apos;message&apos;)</code></p>
<p>详见 <a href="process.html#process_event_message"><code>process</code> event: <code>&apos;message&apos;</code></a>.</p>
<p>在下面这个例子中，我们使用message机制来实现主进程统计cluster中请求数量的功能。</p>
<pre><code class="lang-js">const cluster = require(&apos;cluster&apos;);
const http = require(&apos;http&apos;);

if (cluster.isMaster) {

  // 跟踪 http 请求
  let numReqs = 0;
  setInterval(() =&gt; {
    console.log(`numReqs = ${numReqs}`);
  }, 1000);

  // 计算请求数目
  function messageHandler(msg) {
    if (msg.cmd &amp;&amp; msg.cmd === &apos;notifyRequest&apos;) {
      numReqs += 1;
    }
  }

  // 启动 worker 并监听包含 notifyRequest 的消息
  const numCPUs = require(&apos;os&apos;).cpus().length;
  for (let i = 0; i &lt; numCPUs; i++) {
    cluster.fork();
  }

  for (const id in cluster.workers) {
    cluster.workers[id].on(&apos;message&apos;, messageHandler);
  }

} else {

  // Worker 进程有一个http服务器
  http.Server((req, res) =&gt; {
    res.writeHead(200);
    res.end(&apos;hello world\n&apos;);

    // 通知 master 进程接收到了请求
    process.send({ cmd: &apos;notifyRequest&apos; });
  }).listen(8000);
}
</code></pre>
<h3>Event: &apos;online&apos;<span><a class="mark" href="#cluster_event_online" id="cluster_event_online">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.7.0</span>
</div><p>和<code>cluster.on(&apos;online&apos;)</code>事件类似，但针对特定的工作进程。</p>
<pre><code class="lang-js">cluster.fork().on(&apos;online&apos;, () =&gt; {
  // Worker is online
});
</code></pre>
<p>本事件不会在工作进程内部被触发。</p>
<h3>worker.disconnect()<span><a class="mark" href="#cluster_worker_disconnect" id="cluster_worker_disconnect">#</a></span></h3>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v7.3.0</td>
<td><p>This method now returns a reference to <code>worker</code>.</p>
</td></tr>
<tr><td>v0.7.7</td>
<td><p><span>新增于: v0.7.7</span></p>
</td></tr>
</tbody></table>
</details>
</div><ul>
<li>Returns: <span class="type">&lt;Worker&gt;</span> 一个 <code>worker</code> 的引用。</li>
</ul>
<p>在一个工作进程内，调用此方法会关闭所有的server，并等待这些server的 <code>&apos;close&apos;</code>事件执行，然后关闭IPC管道。</p>
<p>在主进程内，会给工作进程发送一个内部消息，导致工作进程自身调用<code>.disconnect()</code>。</p>
<p>会设置<code>.exitedAfterDisconnect</code> 。</p>
<p>需要注意的是，当一个server关闭后，它将不再接收新的连接，但新连接会被其他正在监听的工作进程接收。已建立的连接可以正常关闭。当所有连接都关闭后，通往该工作进程的IPC管道将会关闭，允许工作进程优雅地死掉，详见 <a href="net.html#net_event_close"><code>server.close()</code></a>。</p>
<p>以上情况只针对服务端连接，工作进程不会自动关闭客户端连接，disconnect方法在退出前并不会等待客户端连接关闭。</p>
<p>需要注意的是，我们这里的方法是<a href="child_process.html#child_process_subprocess_disconnect"><code>disconnect</code></a>，同时还有一个不一样的方法<code>process.disconnect</code>，大家不要混淆了。</p>
<p>由于长时间运行的服务端连接可能导致工作进程的disconnect方法阻塞，我们可以采用发送消息的方法，让应用采取相应的动作来关闭连接。也可以通过设置timeout，当<code>&apos;disconnect&apos;</code>事件在某段时间后仍没有触发时关闭工作进程。</p>
<pre><code class="lang-js">if (cluster.isMaster) {
  const worker = cluster.fork();
  let timeout;

  worker.on(&apos;listening&apos;, (address) =&gt; {
    worker.send(&apos;shutdown&apos;);
    worker.disconnect();
    timeout = setTimeout(() =&gt; {
      worker.kill();
    }, 2000);
  });

  worker.on(&apos;disconnect&apos;, () =&gt; {
    clearTimeout(timeout);
  });

} else if (cluster.isWorker) {
  const net = require(&apos;net&apos;);
  const server = net.createServer((socket) =&gt; {
    // 连接永远不会结束
  });

  server.listen(8000);

  process.on(&apos;message&apos;, (msg) =&gt; {
    if (msg === &apos;shutdown&apos;) {
      // 将所有与服务器的连接优雅关闭
    }
  });
}
</code></pre>
<h3>worker.exitedAfterDisconnect<span><a class="mark" href="#cluster_worker_exitedafterdisconnect" id="cluster_worker_exitedafterdisconnect">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v6.0.0</span>
</div><ul>
<li>
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a></li>
</ul>
<p>当调用 <code>.kill()</code> 或者 <code>.disconnect()</code>方法时被设置，在这之前都是 <code>undefined</code>。</p>
<p><code>worker.exitedAfterDisconnect</code>可以用于区分自发退出还是被动退出，主进程可以根据这个值决定是否重新衍生新的工作进程。</p>
<pre><code class="lang-js">cluster.on(&apos;exit&apos;, (worker, code, signal) =&gt; {
  if (worker.exitedAfterDisconnect === true) {
    console.log(&apos;Oh, it was just voluntary – no need to worry&apos;);
  }
});

// 关闭 worker
worker.kill();
</code></pre>
<h3>worker.id<span><a class="mark" href="#cluster_worker_id" id="cluster_worker_id">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.8.0</span>
</div><ul>
<li>
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a></li>
</ul>
<p>每一个新衍生的工作进程都会被赋予自己独一无二的编号，这个编号就是储存在<code>id</code>里面。</p>
<p>当工作进程还存活时，<code>id</code>可以作为在cluster.workers中的索引。</p>
<h3>worker.isConnected()<span><a class="mark" href="#cluster_worker_isconnected" id="cluster_worker_isconnected">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.11.14</span>
</div><p>当工作进程通过IPC管道连接至主进程时，这个方法返回<code>true</code>，否则返回<code>false</code>。</p>
<p>一个工作进程在创建后会自动连接到它的主进程，当<code>&apos;disconnect&apos;</code> 事件被触发时才会断开连接。</p>
<h3>worker.isDead()<span><a class="mark" href="#cluster_worker_isdead" id="cluster_worker_isdead">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.11.14</span>
</div><p>当工作进程被终止时（包括自动退出或被发送信号），这个方法返回<code>true</code> ，否则返回<code>false</code>。</p>
<h3>worker.kill([signal=&apos;SIGTERM&apos;])<span><a class="mark" href="#cluster_worker_kill_signal_sigterm" id="cluster_worker_kill_signal_sigterm">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.9.12</span>
</div><ul>
<li><code>signal</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 被发送kill信号的工作进程名称。</li>
</ul>
<p>这个方法将会kill工作进程。在主进程中，通过断开与<code>worker.process</code>的连接来实现，一旦断开连接后，通过<code>signal</code>来杀死工作进程。在工作进程中，通过断开IPC管道来实现，然后以代码<code>0</code>退出进程。</p>
<p>将导致<code>.exitedAfterDisconnect</code>被设置。</p>
<p>为向后兼容，这个方法与<code>worker.destroy()</code>等义。</p>
<p>需要注意的是，在工作进程中有一个方法<code>process.kill()</code> ，这个方法本方法不同，本方法是<a href="process.html#process_process_kill_pid_signal"><code>kill</code></a>。</p>
<h3>worker.process<span><a class="mark" href="#cluster_worker_process" id="cluster_worker_process">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.7.0</span>
</div><ul>
<li>
            <a href="child_process.html#child_process_class_childprocess" class="type">&lt;ChildProcess&gt;</a></li>
</ul>
<p>所有的工作进程都是通过<a href="child_process.html#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>来创建的，这个方法返回的对象被存储为<code>.process</code>。在工作进程中， <code>process</code>属于全局对象。</p>
<p>详见：<a href="child_process.html#child_process_child_process_fork_modulepath_args_options">Child Process module</a></p>
<p>需要注意：当<code>process</code>上发生 <code>&apos;disconnect&apos;</code>事件，并且<code>.exitedAfterDisconnect</code>的值不是<code>true</code>时，工作进程会调用 <code>process.exit(0)</code>。这样就可以防止连接意外断开。</p>
<h3>worker.send(message[, sendHandle][, callback])<span><a class="mark" href="#cluster_worker_send_message_sendhandle_callback" id="cluster_worker_send_message_sendhandle_callback">#</a></span></h3>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v4.0.0</td>
<td><p>The <code>callback</code> parameter is supported now.</p>
</td></tr>
<tr><td>v0.7.0</td>
<td><p><span>新增于: v0.7.0</span></p>
</td></tr>
</tbody></table>
</details>
</div><ul>
<li><code>message</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a></li>
<li><code>sendHandle</code> 
            <a href="net.html#net_server_listen_handle_backlog_callback" class="type">&lt;Handle&gt;</a></li>
<li><code>callback</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&lt;Function&gt;</a></li>
<li>返回: 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a></li>
</ul>
<p>发送一个消息给工作进程或主进程，也可以附带发送一个handle。</p>
<p>主进程调用这个方法会发送消息给具体的工作进程。还有一个等价的方法是<a href="child_process.html#child_process_subprocess_send_message_sendhandle_options_callback"><code>ChildProcess.send()</code></a>。</p>
<p>工作进程调用这个方法会发送消息给主进程。还有一个等价方法是<code>process.send()</code>。</p>
<p>这个例子里面，工作进程将主进程发送的消息echo回去。</p>
<pre><code class="lang-js">if (cluster.isMaster) {
  const worker = cluster.fork();
  worker.send(&apos;hi there&apos;);

} else if (cluster.isWorker) {
  process.on(&apos;message&apos;, (msg) =&gt; {
    process.send(msg);
  });
}
</code></pre>
<h3>worker.suicide<span><a class="mark" href="#cluster_worker_suicide" id="cluster_worker_suicide">#</a></span></h3>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v7.0.0</td>
<td><p>Accessing this property will now emit a deprecation warning.</p>
</td></tr>
<tr><td>v6.0.0</td>
<td><p><span>废弃于: v6.0.0</span></p>
</td></tr>
<tr><td>v0.7.0</td>
<td><p><span>新增于: v0.7.0</span></p>
</td></tr>
</tbody></table>
</details>
</div><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#cluster_worker_exitedafterdisconnect"><code>worker.exitedAfterDisconnect</code></a> instead.</div><p>和 <a href="#cluster_worker_exitedafterdisconnect"><code>worker.exitedAfterDisconnect</code></a> 等价.</p>
<p>调用<code>.kill()</code> 或<code>.disconnect()</code>被设置，否则一直是 <code>undefined</code>。</p>
<p> <code>worker.suicide</code>用于区分自发退出或被动退出，主进程可根据这个值来决定是否重新衍生新的工作进程。</p>
<pre><code class="lang-js">cluster.on(&apos;exit&apos;, (worker, code, signal) =&gt; {
  if (worker.suicide === true) {
    console.log(&apos;Oh, it was just voluntary – no need to worry&apos;);
  }
});

// kill worker
worker.kill();
</code></pre>
<p>这个API只是为了向后兼容，未来会删除。</p>
<h2>Event: &apos;disconnect&apos;<span><a class="mark" href="#cluster_event_disconnect_1" id="cluster_event_disconnect_1">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.7.9</span>
</div><ul>
<li><code>worker</code> 
            <a href="cluster.html#cluster_class_worker" class="type">&lt;cluster.Worker&gt;</a></li>
</ul>
<p>在工作进程的IPC管道被断开后触发本事件。可能导致事件触发的原因包括：工作进程优雅地退出、被kill或手动断开连接（如调用worker.disconnect()）。</p>
<p><code>&apos;disconnect&apos;</code> 和 <code>&apos;exit&apos;</code>事件之间可能存在延迟。这些事件可以用来检测进程是否在清理过程中被卡住，或是否存在长时间运行的连接。</p>
<pre><code class="lang-js">cluster.on(&apos;disconnect&apos;, (worker) =&gt; {
  console.log(`The worker #${worker.id} has disconnected`);
});
</code></pre>
<h2>Event: &apos;exit&apos;<span><a class="mark" href="#cluster_event_exit_1" id="cluster_event_exit_1">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.7.9</span>
</div><ul>
<li><code>worker</code> 
            <a href="cluster.html#cluster_class_worker" class="type">&lt;cluster.Worker&gt;</a></li>
<li><code>code</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 正常退出情况下，是退出代码.</li>
<li><code>signal</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 导致进程被kill的信号名称 (例如 <code>&apos;SIGHUP&apos;</code>)</li>
</ul>
<p>当任何一个工作进程关闭的时候，cluster模块都将触发<code>&apos;exit&apos;</code>事件。</p>
<p>可以被用来重启工作进程（通过调用<code>.fork()</code>）。</p>
<pre><code class="lang-js">cluster.on(&apos;exit&apos;, (worker, code, signal) =&gt; {
  console.log(&apos;worker %d died (%s). restarting...&apos;,
              worker.process.pid, signal || code);
  cluster.fork();
});
</code></pre>
<p>详见： <a href="child_process.html#child_process_event_exit">child_process event: &apos;exit&apos;</a>。</p>
<h2>Event: &apos;fork&apos;<span><a class="mark" href="#cluster_event_fork" id="cluster_event_fork">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.7.0</span>
</div><ul>
<li><code>worker</code> 
            <a href="cluster.html#cluster_class_worker" class="type">&lt;cluster.Worker&gt;</a></li>
</ul>
<p>当新的工作进程被fork时，cluster模块将触发<code>&apos;fork&apos;</code>事件。
可以被用来记录工作进程活动，产生一个自定义的timeout。</p>
<pre><code class="lang-js">const timeouts = [];
function errorMsg() {
  console.error(&apos;Something must be wrong with the connection ...&apos;);
}

cluster.on(&apos;fork&apos;, (worker) =&gt; {
  timeouts[worker.id] = setTimeout(errorMsg, 2000);
});
cluster.on(&apos;listening&apos;, (worker, address) =&gt; {
  clearTimeout(timeouts[worker.id]);
});
cluster.on(&apos;exit&apos;, (worker, code, signal) =&gt; {
  clearTimeout(timeouts[worker.id]);
  errorMsg();
});
</code></pre>
<h2>Event: &apos;listening&apos;<span><a class="mark" href="#cluster_event_listening_1" id="cluster_event_listening_1">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.7.0</span>
</div><ul>
<li><code>worker</code> 
            <a href="cluster.html#cluster_class_worker" class="type">&lt;cluster.Worker&gt;</a></li>
<li><code>address</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a></li>
</ul>
<p>当一个工作进程调用<code>listen()</code>后，工作进程上的server会触发<code>&apos;listening&apos;</code> 事件，同时主进程上的 <code>cluster</code> 也会被触发<code>&apos;listening&apos;</code>事件。</p>
<p>事件处理器使用两个参数来执行，其中<code>worker</code>包含了工作进程对象，<code>address</code> 包含了以下连接属性： <code>address</code>、<code>port</code> 和 <code>addressType</code>。当工作进程同时监听多个地址时，这些参数非常有用。</p>
<pre><code class="lang-js">cluster.on(&apos;listening&apos;, (worker, address) =&gt; {
  console.log(
    `A worker is now connected to ${address.address}:${address.port}`);
});
</code></pre>
<p><code>addressType</code> 可选值包括:</p>
<ul>
<li><code>4</code> (TCPv4)</li>
<li><code>6</code> (TCPv6)</li>
<li><code>-1</code> (unix domain socket)</li>
<li><code>&quot;udp4&quot;</code> or <code>&quot;udp6&quot;</code> (UDP v4 or v6)</li>
</ul>
<h2>Event: &apos;message&apos;<span><a class="mark" href="#cluster_event_message_1" id="cluster_event_message_1">#</a></span></h2>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v6.0.0</td>
<td><p>The <code>worker</code> parameter is passed now; see below for details.</p>
</td></tr>
<tr><td>v2.5.0</td>
<td><p><span>新增于: v2.5.0</span></p>
</td></tr>
</tbody></table>
</details>
</div><ul>
<li><code>worker</code> 
            <a href="cluster.html#cluster_class_worker" class="type">&lt;cluster.Worker&gt;</a></li>
<li><code>message</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a></li>
<li><code>handle</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&lt;undefined&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a></li>
</ul>
<p>当cluster主进程接收任意工作进程发送的消息后被触发。</p>
<p>详见： <a href="child_process.html#child_process_event_message">child_process event: &apos;message&apos;</a>。</p>
<p>和文档情况相反的是：在Node.js v6.0版本之前，这个事件仅仅接受两个参数：消息和handle，而没有工作进程对象。</p>
<p>如果要兼容旧版本并且不需要工作进程对象的情况下，可以通过判断参数数量来实现兼容。</p>
<pre><code class="lang-js">cluster.on(&apos;message&apos;, (worker, message, handle) =&gt; {
  if (arguments.length === 2) {
    handle = message;
    message = worker;
    worker = undefined;
  }
  // ...
});
</code></pre>
<h2>Event: &apos;online&apos;<span><a class="mark" href="#cluster_event_online_1" id="cluster_event_online_1">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.7.0</span>
</div><ul>
<li><code>worker</code> 
            <a href="cluster.html#cluster_class_worker" class="type">&lt;cluster.Worker&gt;</a></li>
</ul>
<p>当新建一个工作进程后，工作进程应当响应一个online消息给主进程。当主进程收到online消息后触发这个事件。
 <code>&apos;fork&apos;</code> 事件和 <code>&apos;online&apos;</code>事件的不同之处在于，前者是在主进程新建工作进程后触发，而后者是在工作进程运行的时候触发。</p>
<pre><code class="lang-js">cluster.on(&apos;online&apos;, (worker) =&gt; {
  console.log(&apos;Yay, the worker responded after it was forked&apos;);
});
</code></pre>
<h2>Event: &apos;setup&apos;<span><a class="mark" href="#cluster_event_setup" id="cluster_event_setup">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.7.1</span>
</div><ul>
<li><code>settings</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a></li>
</ul>
<p>每当 <code>.setupMaster()</code>  被调用的时候触发。</p>
<p><code>settings</code> 对象是 <code>setupMaster()</code> 被调用时的 <code>cluster.settings</code> 对象，并且只能查询，因为在一个 tick 内 <code>.setupMaster()</code> 可以被调用多次。</p>
<p>如果精确度十分重要，请使用 <code>cluster.settings</code>。</p>
<h2>cluster.disconnect([callback])<span><a class="mark" href="#cluster_cluster_disconnect_callback" id="cluster_cluster_disconnect_callback">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.7.7</span>
</div><ul>
<li><code>callback</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&lt;Function&gt;</a> 当所有工作进程都断开连接并且所有handle关闭的时候调用。</li>
</ul>
<p>在<code>cluster.workers</code>的每个工作进程中调用 <code>.disconnect()</code>。</p>
<p>当所有工作进程断开连接后，所有内部handle将会关闭，这个时候如果没有等待事件的话，运行主进程优雅地关闭。</p>
<p>这个方法可以选择添加一个回调参数，当结束时会调用这个回调函数。</p>
<p>这个方法只能由主进程调用。</p>
<h2>cluster.fork([env])<span><a class="mark" href="#cluster_cluster_fork_env" id="cluster_cluster_fork_env">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.6.0</span>
</div><ul>
<li><code>env</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a> 增加进程环境变量，以Key/value对的形式。</li>
<li>return 
            <a href="cluster.html#cluster_class_worker" class="type">&lt;cluster.Worker&gt;</a></li>
</ul>
<p>衍生出一个新的工作进程。</p>
<p>只能通过主进程调用。</p>
<h2>cluster.isMaster<span><a class="mark" href="#cluster_cluster_ismaster" id="cluster_cluster_ismaster">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.8.1</span>
</div><ul>
<li>
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a></li>
</ul>
<p>当该进程是主进程时，返回 true。这是由<code>process.env.NODE_UNIQUE_ID</code>决定的，当<code>process.env.NODE_UNIQUE_ID</code>未定义时，<code>isMaster</code>为<code>true</code>。</p>
<h2>cluster.isWorker<span><a class="mark" href="#cluster_cluster_isworker" id="cluster_cluster_isworker">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.6.0</span>
</div><ul>
<li>
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a></li>
</ul>
<p>当进程不是主进程时，返回 true。（和<code>cluster.isMaster</code>刚好相反）</p>
<h2>cluster.schedulingPolicy<span><a class="mark" href="#cluster_cluster_schedulingpolicy" id="cluster_cluster_schedulingpolicy">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.11.2</span>
</div><p>调度策略，包括循环计数的 <code>cluster.SCHED_RR</code>，以及由操作系统决定的<code>cluster.SCHED_NONE</code>。
这是一个全局设置，当第一个工作进程被衍生或者调动<code>cluster.setupMaster()</code>时，都将第一时间生效。</p>
<p>除Windows外的所有操作系统中，<code>SCHED_RR</code>都是默认设置。只要libuv可以有效地分发IOCP handle，而不会导致严重的性能冲击的话，Windows系统也会更改为<code>SCHED_RR</code>。</p>
<p><code>cluster.schedulingPolicy</code> 可以通过设置<code>NODE_CLUSTER_SCHED_POLICY</code>环境变量来实现。这个环境变量的有效值包括<code>&quot;rr&quot;</code> 和 <code>&quot;none&quot;</code>。</p>
<h2>cluster.settings<span><a class="mark" href="#cluster_cluster_settings" id="cluster_cluster_settings">#</a></span></h2>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>8.2.0</td>
<td><p>The <code>inspectPort</code> option is supported now.</p>
</td></tr>
<tr><td>v6.4.0</td>
<td><p>The <code>stdio</code> option is supported now.</p>
</td></tr>
<tr><td>v0.7.1</td>
<td><p><span>新增于: v0.7.1</span></p>
</td></tr>
</tbody></table>
</details>
</div><ul>
<li>
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a><ul>
<li><code>execArgv</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a> 传递给Node.js可执行文件的参数列表。 (Default=<code>process.execArgv</code>)</li>
<li><code>exec</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> worker文件路径。 (Default=<code>process.argv[1]</code>)</li>
<li><code>args</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a> 传递给worker的参数。(Default=<code>process.argv.slice(2)</code>)</li>
<li><code>silent</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 是否需要发送输出值父进程的stdio。(Default=<code>false</code>)</li>
<li><code>stdio</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a> 配置fork进程的stdio。  由于cluster模块运行依赖于IPC，这个配置必须包含<code>&apos;ipc&apos;</code>。当提供了这个选项后，将撤销<code>silent</code>。</li>
<li><code>uid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置进程的user标识符。 (见 <a href="http://man7.org/linux/man-pages/man2/setuid.2.html">setuid(2)</a>.)</li>
<li><code>gid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置进程的group标识符。 (见 <a href="http://man7.org/linux/man-pages/man2/setgid.2.html">setgid(2)</a>.)</li>
<li><code>inspectPort</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> | <span class="type">&lt;function&gt;</span> Sets inspector port of worker.
This can be a number, or a function that takes no arguments and returns a
number. By default each worker gets its own port, incremented from the
master&apos;s <code>process.debugPort</code>.</li>
</ul>
</li>
</ul>
<p>调用<code>.setupMaster()</code> (或 <code>.fork()</code>)后，这个settings对象将会包含这些设置项，包括默认值。</p>
<p>这个对象不打算被修改或手动设置。</p>
<h2>cluster.setupMaster([settings])<span><a class="mark" href="#cluster_cluster_setupmaster_settings" id="cluster_cluster_setupmaster_settings">#</a></span></h2>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v6.4.0</td>
<td><p>The <code>stdio</code> option is supported now.</p>
</td></tr>
<tr><td>v0.7.1</td>
<td><p><span>新增于: v0.7.1</span></p>
</td></tr>
</tbody></table>
</details>
</div><ul>
<li><code>settings</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a> 详见 <a href="#cluster_cluster_settings"><code>cluster.settings</code></a>。</li>
</ul>
<p>用于修改默认&apos;fork&apos; 行为。一旦调用，将会按照<code>cluster.settings</code>进行设置。</p>
<p>注意:</p>
<ul>
<li>所有的设置只对后来的 <code>.fork()</code>调用有效，对之前的工作进程无影响。</li>
<li>唯一无法通过 <code>.setupMaster()</code>设置的属性是传递给<code>.fork()</code>的<code>env</code>属性。</li>
<li>上述的默认值只在第一次调用时有效，当后续调用时，将采用<code>cluster.setupMaster()</code>调用时的当前值。</li>
</ul>
<p>例子:</p>
<pre><code class="lang-js">const cluster = require(&apos;cluster&apos;);
cluster.setupMaster({
  exec: &apos;worker.js&apos;,
  args: [&apos;--use&apos;, &apos;https&apos;],
  silent: true
});
cluster.fork(); // https worker
cluster.setupMaster({
  exec: &apos;worker.js&apos;,
  args: [&apos;--use&apos;, &apos;http&apos;]
});
cluster.fork(); // http worker
</code></pre>
<p>只能由主进程调用。</p>
<h2>cluster.worker<span><a class="mark" href="#cluster_cluster_worker" id="cluster_cluster_worker">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.7.0</span>
</div><ul>
<li>
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a></li>
</ul>
<p>当前工作进程对象的引用，对于主进程则无效。</p>
<pre><code class="lang-js">const cluster = require(&apos;cluster&apos;);

if (cluster.isMaster) {
  console.log(&apos;I am master&apos;);
  cluster.fork();
  cluster.fork();
} else if (cluster.isWorker) {
  console.log(`I am worker #${cluster.worker.id}`);
}
</code></pre>
<h2>cluster.workers<span><a class="mark" href="#cluster_cluster_workers" id="cluster_cluster_workers">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v0.7.0</span>
</div><ul>
<li>
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a></li>
</ul>
<p>这是一个哈希表，储存了活跃的工作进程对象，<code>id</code>作为key。有了它，可以方便地遍历所有工作进程。只能在主进程中调用。</p>
<p>工作进程断开连接以及退出后，将会从cluster.workers里面移除。这两个事件的先后顺序并不能预先确定，但可以保证的是，
cluster.workers的移除工作在<code>&apos;disconnect&apos;</code> 和 <code>&apos;exit&apos;</code>两个事件中的最后一个触发之前完成。</p>
<pre><code class="lang-js">// Go through all workers
function eachWorker(callback) {
  for (const id in cluster.workers) {
    callback(cluster.workers[id]);
  }
}
eachWorker((worker) =&gt; {
  worker.send(&apos;big announcement to all workers&apos;);
});
</code></pre>
<p>使用工作进程的id来进行定位索引是最方便的！</p>
<pre><code class="lang-js">socket.on(&apos;data&apos;, (id) =&gt; {
  const worker = cluster.workers[id];
});
</code></pre>

      </div>
    </div>

    <div id="column2" class="interior">
      <div id="intro" class="interior">
        <a href="/" title="Go back to the home page">
          Node.js 中文文档 | Node.js 中文网
        </a>
      </div>
      
        <!-- [start-include:_toc.md] -->
<ul>
<li><a href="documentation.html">关于本文档</a></li>
<li><a href="synopsis.html">用法与例子</a></li>
</ul>
<div class="line"></div>

<ul>
<li><a href="assert.html">断言测试</a></li>
<li><a href="async_hooks.html">异步钩子（Async Hooks）</a></li>
<li><a href="buffer.html">缓存（Buffer）</a></li>
<li><a href="addons.html">C++ 插件</a></li>
<li><a href="n-api.html">C/C++ 插件 - N-API</a></li>
<li><a href="child_process.html">子进程</a></li>
<li><a href="cluster.html">集群（Cluster）</a></li>
<li><a href="cli.html">命令行参数</a></li>
<li><a href="console.html">控制台（Console）</a></li>
<li><a href="crypto.html">加密（Crypto）</a></li>
<li><a href="debugger.html">调试器</a></li>
<li><a href="deprecations.html">废弃的 API</a></li>
<li><a href="dns.html">DNS</a></li>
<li><a href="domain.html">域（Domain）</a></li>
<li><a href="esm.html">ECMAScript 模块</a></li>
<li><a href="errors.html">错误（Errors）</a></li>
<li><a href="events.html">事件（Events）</a></li>
<li><a href="fs.html">文件系统</a></li>
<li><a href="globals.html">全局对象（Globals）</a></li>
<li><a href="http.html">HTTP</a></li>
<li><a href="http2.html">HTTP/2</a></li>
<li><a href="https.html">HTTPS</a></li>
<li><a href="inspector.html">检查工具（Inspector）</a></li>
<li><a href="intl.html">国际化</a></li>
<li><a href="modules.html">模块（Modules）</a></li>
<li><a href="net.html">网络（Net）</a></li>
<li><a href="os.html">操作系统（OS）</a></li>
<li><a href="path.html">路径（Path）</a></li>
<li><a href="perf_hooks.html">性能钩子（Performance Hooks）</a></li>
<li><a href="process.html">进程</a></li>
<li><a href="punycode.html">Punycode</a></li>
<li><a href="querystring.html">查询字符串</a></li>
<li><a href="readline.html">逐行读取</a></li>
<li><a href="repl.html">交互式解释器（REPL）</a></li>
<li><a href="stream.html">流（Stream）</a></li>
<li><a href="string_decoder.html">字符串解码</a></li>
<li><a href="timers.html">定时器（Timers）</a></li>
<li><a href="tls.html">安全传输层（TLS/SSL）</a></li>
<li><a href="tracing.html">事件跟踪（Tracing）</a></li>
<li><a href="tty.html">TTY</a></li>
<li><a href="dgram.html">UDP / 数据报</a></li>
<li><a href="url.html">URL</a></li>
<li><a href="util.html">工具集</a></li>
<li><a href="v8.html">V8</a></li>
<li><a href="vm.html">虚拟机（VM）</a></li>
<li><a href="zlib.html">压缩（ZLIB）</a></li>
</ul>
<div class="line"></div>

<ul>
<li><a href="https://github.com/nodejs/node">GitHub 仓库和问题跟踪</a></li>
<li><a href="https://groups.google.com/group/nodejs">邮件列表</a></li>
</ul>
<!-- [end-include:_toc.md] -->

      
    </div>
  </div>
  <script src="assets/sh_main.js"></script>
  <script src="assets/sh_javascript.min.js"></script>
  <script>highlight(undefined, undefined, 'pre');</script>
</body>
</html>
